A Map-Reduce Parallel Approach to Automatic Synthesis of Control Software

Many Control Systems are indeed Software Based Control Systems, i.e. control systems whose controller consists of control software running on a microcontroller device. This motivates investigation on Formal Model Based Design approaches for automatic synthesis of control software. Available algorithms and tools (e.g., QKS) may require weeks or even months of computation to synthesize control software for large-size systems. This motivates search for parallel algorithms for control software synthesis. In this paper, we present a Map-Reduce style parallel algorithm for control software synthesis when the controlled system (plant) is modeled as discrete time linear hybrid system. Furthermore we present an MPI-based implementation PQKS of our algorithm. To the best of our knowledge, this is the first parallel approach for control software synthesis. We experimentally show effectiveness of PQKS on two classical control synthesis problems: the inverted pendulum and the multi-input buck DC/DC converter. Experiments show that PQKS efficiency is above 65%. As an example, PQKS requires about 16 hours to complete the synthesis of control software for the pendulum on a cluster with 60 processors, instead of the 25 days needed by the sequential algorithm in QKS.Comment: To be submitted to TACAS 2013. arXiv admin note: substantial text overlap with arXiv:1207.4474, arXiv:1207.409

Precision On Demand:

In explicit state (enumerative) model checking, state vectors are often represented in a compressed form in order to reduce storage needs, typically employing fingerprints, bithashes, or state signatures. When using this kind of techniques, it could happen that the compressed image of a nonvisited state s matches that of a visited state s ′ � = s, thus s and potentially many of its descendants are omitted from search. If any of these omitted states was an error state, we could also have false positives. We present a new technique which reduces the number of omitted states, by requiring a slightly higher computation time, but without employing any additional memory. Our technique works for depth-first search based state exploration, and exploits the fact that when a non-terminal state t is represented in the hash table, then one of the successors of t (the first to be expanded next, typically the left-most) is also represented in the visited states hash table. Therefore, instead of backing off when the compressed state images match, our algorithm persists to see if any of the left-most successors also matches (the number of successors which are considered for each state is user-defined, thus we name our approach Precision on Demand or POD). This paper provides a scientific evaluation of the pros and cons of this approach. We have implemented the algorithm in two versions of the Murphi explicit state model checker, one based on hash compaction and the other based on Bloom filters, and present experimental results. Our results indicate that POD-hashing has the potential to reduce storage requirements- or increase the number of bugs likely to be caught when operating within a given amount of storage, with the execution time likely to increase by a factor of 1.8 or less

Any-horizon uniform random sampling and enumeration of constrained scenarios for simulation-based formal verification

Model-based approaches to the verification of non-terminating Cyber-Physical Systems (CPSs) usually rely on numerical simulation of the System Under Verification (SUV) model under input scenarios of possibly varying duration, chosen among those satisfying given constraints. Such constraints typically stem from requirements (or assumptions) on the SUV inputs and its operational environment as well as from the enforcement of additional conditions aiming at, e.g., prioritising the (often extremely long) verification activity, by, e.g., focusing on scenarios explicitly exercising selected requirements, or avoiding vacuity in their satisfaction. In this setting, the possibility to efficiently sample at random (with a known distribution, e.g., uniformly) within, or to efficiently enumerate (possibly in a uniformly random order) scenarios among those satisfying all the given constraints is a key enabler for the practical viability of the verification process, e.g., via simulation-based statistical model checking. Unfortunately, in case of non-trivial combinations of constraints, iterative approaches like Markovian random walks in the space of sequences of inputs in general fail in extracting scenarios according to a given distribution (e.g., uniformly), and can be very inefficient to produce at all scenarios that are both legal (with respect to SUV assumptions) and of interest (with respect to the additional constraints). For example, in our case studies, up to 91% of the scenarios generated using such iterative approaches would need to be neglected. In this article, we show how, given a set of constraints on the input scenarios succinctly defined by multiple finite memory monitors, a data structure (scenario generator) can be synthesised, from which any-horizon scenarios satisfying the input constraints can be efficiently extracted by (possibly uniform) random sampling or (randomised) enumeration. Our approach enables seamless support to virtually all simulation-based approaches to CPS verification, ranging from simple random testing to statistical model checking and formal (i.e., exhaustive) verification, when a suitable bound on the horizon or an iterative horizon enlargement strategy is defined, as in the spirit of bounded model checking

Linear Constraints and Guarded Predicates as a Modeling Language for Discrete Time Hybrid Systems

Model based design is particularly appealing in software based control systems (e.g., embedded software) design, since in such a case system level specifications are much easier to define than the control software behavior itself. In turn, model based design of embedded systems requires modeling both continuous subsystems (typically, the plant) as well as discrete subsystems (the controller). This is typically done using hybrid systems. Mixed Integer Linear Programming (MILP) based abstraction techniques have been successfully applied to automatically synthesize correct-by-construction control software for discrete time linear hybrid systems, where plant dynamics is modeled as a linear predicate over state, input, and next state variables. Unfortunately, MILP solvers require such linear predicates to be conjunctions of linear constraints, which is not a natural way of modeling hybrid systems. In this paper we show that, under the hypothesis that each variable ranges over a bounded interval, any linear predicate built upon conjunction and disjunction of linear constraints can be automatically translated into an equivalent conjunctive predicate. Since variable bounds play a key role in this translation, our algorithm includes a procedure to compute all implicit variable bounds of the given linear predicate. Furthermore, we show that a particular form of linear predicates, namely guarded predicates, are a natural and powerful language to succinctly model discrete time linear hybrid systems dynamics. Finally, we experimentally show the feasibility of our approach on an important and challenging case study taken from the literature, namely the multi-input Buck DC-DC Converter. As an example, the guarded predicate that models (with 57 constraints) a 6-inputs Buck DC-DC Converter is translated in a conjunctive predicate (with 102 linear constraints) in about 40 minutes

A Constraint Optimization–Based Sense and Response System for Interactive Business Performance Management

A Sense and Respond (SaR) system endows a Business Intelligence system with the intelligence needed to react timely to exogenous as well as endogenous events. To this end, a SaR system needs to know the Key Performance Indicators (KPIs) that must be maximized as well as their relative weights. While the first information can be easily obtained through interviews, the second one is quite hard to get. This motivates the investigation of methods and tools to address this problem. In such a context, the main contributions of this paper are the following. First, we show how KPIs can be effectively defined using linear constraints. Second, we show how the problem of computing the actions that the SaR system proposes to the manager can be formulated as a Mixed Integer Linear Programming (MILP) problem. Third, we show how KPI weights can be computed from previous managing decisions by solving a suitable MILP problem. Fourth, we provide experimental results showing the effectiveness of the proposed approach

A multi-hop advertising discovery and delivering protocol for multi administrative domain MANET

A Mobile Ad-hoc NETwork (MANET) is Multi Administrative Domain (MAD) if each network node belongs to an independent authority, that is each node owns its resources and there is no central authority owning all network nodes. One of the main obstructions in designing Service Advertising, Discovery and Delivery (SADD) protocol for MAD MANETs is the fact that, in an attempt to increase their own visibility, network nodes tend to flood the network with their advertisements. In this paper, we present a SADD protocol for MAD MANET, based on Bloom filters, that effectively prevents advertising floods due to such misbehaving nodes. Our results with the ns-2 simulator show that our SADD protocol is effective in counteracting advertising floods, it keeps low the collision rate as well as the energy consumption while ensuring that each peer receives all messages broadcasted by other peers

Exploiting hub states in automatic verification

In this paper we present a new algorithm to counteract state explosion when using Explicit State Space Exploration to verify protocol-like systems. We sketch the implementation of our algorithm within the Caching Mur psi verifier and give experimental results showing its effectiveness. We show experimentally that, when memory is a scarce resource, our algorithm improves on the time performances of Caching Mur psi verification algorithm, saving between 16% and 68% (45% on average) in computation time

Finite horizon analysis of Markov Chains with the Murphi verifier

In this paper we present an explicit disk-based verification algorithm for Probabilistic Systems defining discrete time/finite state Markov Chains. Given a Markov Chain and an integer k (horizon), our algorithm checks whether the probability of reaching an error state in at most k steps is below a given threshold. We present an implementation of our algorithm within a suitable extension of the Murϕ verifier. We call the resulting probabilistic model checker FHP-Murϕ (Finite Horizon ProbabilisticMurϕ). We present experimental results comparing FHP-Murϕ with (a finite horizon subset of) PRISM, a state-of-the-art symbolic model checker for Markov Chains. Our experimental results show that FHP-Murϕ can handle systems that are out of reach for PRISM, namely those involving arithmetic operations on the state variables (e.g. hybrid systems)